;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;
; 51mathx.inc is een driver die subroutines bevat voor wiskundige berekeningen.
; Het is niet de bedoeling om de meest compacte code te bekomen. De driver zal
; ook niet alle gewenste routines bevatten. Hij is geschreven met pedagogische
; doelstellingen in het achterhoofd. 
; 
; De driver bevat routines voor 8 bit bcd naar hex en hex naar bcd omvorming
; LET OP!!!! de getallen moeten in waarde kleiner dan 100d zijn (zowel hex als
; bcd)
;      8bit hex naar bcd
;      8bit bcd naar hex
;
; De driver bevat routines voor de 4 hoofdbewerkingen op 16 bit getallen:
;      16/16 bit met 16 bit uitkomst en 16 bit rest
;      16*16 bit met 32 bit uitkomst
;      16+16 bit met 24 bit uitkomst
;      16-16 bit met 24 bit uitkomst
;      16bit hex naar bcd
;      16bit bcd naar hex
;
; De driver bevat routines voor de 4 hoofdbewerkingen op 32 bit getallen:
;      32/32 bit met 32 bit uitkomst en 32 bit rest
;      32*32 bit met 64 bit uitkomst
;      32+32 bit met 40 bit uitkomst
;      32-32 bit met 40 bit uitkomst
;
; de gebruiker moet zorgen dat de berekeningen mogelijk zijn!!!!!!!!!!!!!!!!!!
; 
; De routines gebruiken als input en output de huidige registerbank.
; 
; geschreven door Roggemans Marc (MGM) op 11/2004 uitvoering 51math0.inc
;
;
; WAARSCHUWING!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
; DEZE ROUTINES GEBRUIKEN 15 BYTES STACK. ZE WERKEN ENKEL ALS DE STACK NIET DE
; ADRESSEN 20-30 GEBRUIKT. ER WORDEN HIER IMMERS DIRECT ADRESSEERBARE REGISTERS
; VRIJ GEMAAKT OM IN TE REKENEN.
; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

; Hier worden gpr's verbonden met een naam. Ze worden gebruikt door sommige
; routines. Omdat ze informatie kunnen bevatten worden ze op de stack gezet.

h0            equ    020h
h1            equ    021h
h2            equ    022h
h3            equ    023h
h4            equ    024h
h5            equ    025h
h6            equ    026h
h7            equ    027h
h8            equ    028h
h9            equ    029h
h10           equ    02ah
h11           equ    02bh
h12           equ    02ch

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;
; mul32       is de routine die twee 32 bit getallen zal vermenigvuldigen.
; input:      r3,r2,r1,r0 = eerste getal (r3=msb)
;             r7,r6,r5,r4 = tweede getal (r7=msb)
; output:     r7,r6,r5,r4,r3,r2,r1,r0 met r7=msb
;
; De routine gebruikt alleen de registers van de huidig geselecteerde bank
;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

mul32:        push   acc                  ;registers op de stack zetten
              push   psw
              push   h0
              push   h1
              push   h2
              push   h3
              push   h4
              push   h5
              push   h6
              push   h7
              push   h8
              push   h9
              push   h10
              push   h11
              push   h12

; eerst moeten de hulpregisters klaar gezet worden

              mov    h0,#000h
              mov    h1,#000h
              mov    h2,#000h
              mov    h3,#000h
              mov    h4,#000h
              mov    h5,#000h
              mov    h6,#000h
              mov    h7,#000h
              mov    h8,#000h
              mov    h9,#000h
              mov    h10,#000h
              mov    h11,#000h
              mov    h12,#32d             ;loopcounter

; volgende lus moet 32 keer doorlopen worden om de berekening te maken

; nu wordt de vermenigvuldiger naar rechts in de carry geshift

mul321:       mov    a,r3
              rrc    a
              mov    r3,a
              mov    a,r2
              rrc    a
              mov    r2,a
              mov    a,r1
              rrc    a
              mov    r1,a
              mov    a,r0
              rrc    a
              mov    r0,a                 ;32 bit shift klaar

;als de carry 1 is moet het 64 bit getal h3-r4 opgeteld worden bij h11-h4

              jnc    mul322               ;optelling niet nodig

; hier staat en 64 bit optelling

              mov    a,r4
              add    a,h4
              mov    h4,a
              mov    a,r5
              addc   a,h5
              mov    h5,a
              mov    a,r6
              addc   a,h6
              mov    h6,a
              mov    a,r7
              addc   a,h7
              mov    h7,a
              mov    a,h0
              addc   a,h8
              mov    h8,a
              mov    a,h1
              addc   a,h9
              mov    h9,a
              mov    a,h2
              addc   a,h10
              mov    h10,a
              mov    a,h3
              addc   a,h11
              mov    h11,a                ;optelling klaar

; het getal h3-r4 moet met twee vermenigvuldigd worden

mul322:       clr    c                    ;moet op 0 staan
              mov    a,r4
              rlc    a
              mov    r4,a
              mov    a,r5
              rlc    a
              mov    r5,a
              mov    a,r6
              rlc    a
              mov    r6,a
              mov    a,r7
              rlc    a
              mov    r7,a
              mov    a,h0
              rlc    a
              mov    h0,a
              mov    a,h1
              rlc    a
              mov    h1,a
              mov    a,h2
              rlc    a
              mov    h2,a
              mov    a,h3
              rlc    a
              mov    h3,a

              djnz   h12,mul321           ;herhaal 32 keer

; de uitkomst moet in de juiste registers komen

              mov    r0,h4
              mov    r1,h5
              mov    r2,h6
              mov    r3,h7
              mov    r4,h8
              mov    r5,h9
              mov    r6,h10
              mov    r7,h11               ;klaar

              pop    h12                  ;registers herstellen
              pop    h11
              pop    h10
              pop    h9
              pop    h8
              pop    h7
              pop    h6
              pop    h5
              pop    h4
              pop    h3
              pop    h2
              pop    h1
              pop    h0
              pop    psw
              pop    acc
              ret

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;
; mul16       is de routine die twee 16 bit getallen zal vermenigvuldigen.
; input:      r1,r0 = eerste getal (r1=msb)
;             r3,r2 = tweede getal (r3=msb)
; output:     r3,r2,r1,r0 met r3=msb
;
; De routine gebruikt alleen de registers r3, r2, r1, r0 van de huidige bank
;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

mul16:        push   acc                  ;registers op de stack zetten
              push   psw
              push   h0
              push   h1
              push   h2
              push   h3
              push   h4
              push   h5
              push   h6

; eerst registers laden met startwaarden. h0 en h1 zijn het verlengstuk
; van r3 en r2. h2, h3, h4, h5 worden gebruikt voor sommatie.
; h6 is de loopcounter.

              mov    h0,#000h
              mov    h1,#000h
              mov    h2,#000h
              mov    h3,#000h
              mov    h4,#000h
              mov    h5,#000h
              mov    h6,#16d              ;loopcounter
              
; hier staat de lus die 16 keer doorlopen wordt voor het uitvoeren van de
; berekening

mul161:       mov    a,r1                 ;getal 1 1*rechts in carry
              rrc    a
              mov    r1,a
              mov    a,r0
              rrc    a
              mov    r0,a                 ;ok

; als carry 1 dan h1, h0, r3, r2 optellen bij h5, h4, h3, h2

              jnc    mul162

              mov    a,r2
              add    a,h2
              mov    h2,a                 ;32 bit som uitvoeren
              mov    a,r3
              addc   a,h3
              mov    h3,a
              mov    a,h0
              addc   a,h4
              mov    h4,a
              mov    a,h1
              addc   a,h5
              mov    h5,a                 ;klaar

; het te vermenigvuldige getal maal 2 (1*links shiften)

mul162:       clr    c
              mov    a,r2
              rlc    a
              mov    r2,a                 ;ook 32 bit getal
              mov    a,r3
              rlc    a
              mov    r3,a
              mov    a,h0
              rlc    a
              mov    h0,a
              mov    a,h1
              rlc    a
              mov    h1,a                 ;klaar

              djnz   h6,mul161            ;herhaal 16 keer

; de vermenigvuldiging is klaar. Nu uitkomstregisters laden

              mov    r0,h2
              mov    r1,h3
              mov    r2,h4
              mov    r3,h5                ;klaar


              pop    h6                   ;registers herstellen
              pop    h5
              pop    h4
              pop    h3
              pop    h2
              pop    h1
              pop    h0
              pop    psw
              pop    acc
              ret

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;
; div32       is de routine die twee 32 bit getallen zal delen (eerste/tweede).
; input:      r3,r2,r1,r0 = eerste getal (r3=msb)
;             r7,r6,r5,r4 = tweede getal (r7=msb)
; output:     r7,r6,r5,r4 = quotient (r7=msb)
;             r3,r2,r1,r0 = rest (r3=msb)
;             carry=1 bij delen door 0
;
; De routine gebruikt alleen de registers van de huidig geselecteerde bank
;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

div32:        push   acc                  ;registers op de stack zetten
              push   psw
              push   h0
              push   h1
              push   h2
              push   h3
              push   h4
              push   h5
              push   h6
              push   h7
              push   h8
              push   h9
              push   h10
              push   h11
              push   h12

; eerst alles voorladen

              mov    h0,#000h
              mov    h1,#000h
              mov    h2,#000h
              mov    h3,#000h
              mov    h4,#000h
              mov    h5,#000h
              mov    h6,#000h
              mov    h7,#000h
              mov    h8,#000h
              mov    h9,#000h
              mov    h10,#000h
              mov    h11,#000h
              mov    h12,#32d             ;loopcounter

; we gaan het te delen getal in de passende hulpregisters shiften

; deze lus moet 32 keer heraald worden

div321:       mov    a,r0                 ;h3-r0 is te delen getal
              rlc    a
              mov    r0,a
              mov    a,r1
              rlc    a
              mov    r1,a
              mov    a,r2
              rlc    a
              mov    r2,a
              mov    a,r3
              rlc    a
              mov    r3,a
              mov    a,h0
              rlc    a
              mov    h0,a
              mov    a,h1
              rlc    a
              mov    h1,a
              mov    a,h2
              rlc    a
              mov    h2,a
              mov    a,h3
              rlc    a
              mov    h3,a

; nu testen of het deeltal in h3-h0 past, tussenuitkomst in h7-h4

              clr    c                    ;zit in de weg
              mov    a,h0
              subb   a,r4
              mov    h4,a
              mov    a,h1
              subb   a,r5
              mov    h5,a
              mov    a,h2
              subb   a,r6
              mov    h6,a
              mov    a,h3
              subb   a,r7
              mov    h7,a

; als er geen carry is, dan is het verschil succesvol, en moeten h3-h0
; vervangen worden door h7-h4

              jc     div322               ;niet vervangen

              mov    h0,h4
              mov    h1,h5
              mov    h2,h6
              mov    h3,h7                ;vervanging klaar

div322:       cpl    c                    ;dit moet in h11-h8 (uitkomst)
              mov    a,h8
              rlc    a
              mov    h8,a
              mov    a,h9
              rlc    a
              mov    h9,a
              mov    a,h10
              rlc    a
              mov    h10,a
              mov    a,h11
              rlc    a
              mov    h11,a                ;qoutient aangepast

              djnz   h12,div321           ;32 keer herhalen

; de berekening is klaar. uitkomstregisters nog laden

              mov    r4,h8
              mov    r5,h9
              mov    r6,h10
              mov    r7,h11               ;uitkomst geladen

              mov    r0,h0                ;rest laden
              mov    r1,h1
              mov    r2,h2
              mov    r3,h3

              pop    h12                  ;registers herstellen
              pop    h11
              pop    h10
              pop    h9
              pop    h8
              pop    h7
              pop    h6
              pop    h5
              pop    h4
              pop    h3
              pop    h2
              pop    h1
              pop    h0
              pop    psw
              pop    acc
              ret


;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;
; div16       is de routine die twee 16 bit getallen zal delen (eerste/tweede).
; input:      r1,r0 = eerste getal (r1=msb)
;             r3,r2 = tweede getal (r3=msb)
; output:     r3,r2 = quotient (r3=msb)
;             r1,r0 = rest (r1=msb)
;             carry=1 bij deling door 0
;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

div16:        push   acc                  ;registers op de stack zetten
              push   psw
              push   h0
              push   h1
              push   h2
              push   h3
              push   h4
              push   h5
              push   h6

; registers voorladen

              mov    h0,#000h
              mov    h1,#000h
              mov    h2,#000h
              mov    h3,#000h
              mov    h4,#000h
              mov    h5,#000h
              mov    h6,#16d              ;loopcounter
              
; eerst te delen getal 1*links shiften in hulpregisters

; deze lus moet 16 keer herhaald worden

div161:       mov    a,r0                 ;32 bit shift in h1-r0
              rlc    a
              mov    r0,a
              mov    a,r1
              rlc    a
              mov    r1,a
              mov    a,h0
              rlc    a
              mov    h0,a
              mov    a,h1
              rlc    a
              mov    h1,a

; nagaan of in h1-h0 de deler past r3-r2. h3-h2 wordt gebruikt voor
; het tussenresultaat.

              clr    c
              mov    a,h0
              subb   a,r2
              mov    h2,a
              mov    a,h1
              subb   a,r3
              mov    h3,a

              jc     div162               ;als carry dan h1-h0 niet vervangen
                                          ;door h3,h2
              mov    h0,h2
              mov    h1,h3                ;vervanging klaar

; uitkomst moet aangepast worden

div162:       cpl    c                    ;truuk
              mov    a,h4
              rlc    a
              mov    h4,a
              mov    a,h5
              rlc    a
              mov    h5,a
              djnz   h6,div161            ;16 keer herhalen

; de berekening is klaar. uitkomsten in passende registers

              mov    r2,h4                ;quotient
              mov    r3,h5

              mov    r0,h0                ;rest
              mov    r1,h1

              pop    h6                   ;registers herstellen
              pop    h5
              pop    h4
              pop    h3
              pop    h2
              pop    h1
              pop    h0
              pop    psw
              pop    acc
              ret

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;
; add32       zal twee 32 bit getallen optellen en een 40 bit uitkomst.
;
; input:      r3,r2,r1,r0 = eerste getal (r3=msb)
;             r7,r6,r5,r4 = tweede getal (r7=msb)
; output:     r4,r3,r2,r1,r0 (r4=msb)
;
; r4,r3,r2,r1,r0 worden aangepast
;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

add32:        push   acc                  ;registers op de stack zetten
              push   psw
              mov    a,r0                 ;eerste 8 bit
              add    a,r4
              mov    r0,a                 ;klaar
              mov    a,r1                 ;volgende 8 bit
              addc   a,r5
              mov    r1,a                 ;klaar
              mov    a,r2                 ;volgende 8 bit
              addc   a,r6
              mov    r2,a                 ;klaar
              mov    a,r3                 ;laatste 8 bit
              addc   a,r7
              mov    r3,a                 ;32 bit klaar
              mov    a,#000h
              addc   a,#000h              ;carry verrekenen
              mov    r4,a
              pop    psw                  ;registers herstellen
              pop    acc
              ret

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;
; add16       zal twee 16 bit getallen optellen en een 24 bit uitkomst.
;
; input:      r1,r0 = eerste getal (r1=msb)
;             r3,r2 = tweede getal (r3=msb)
; output:     r2,r1,r0 (r2=msb)
;
; r3,r2,r1,r0 worden aangepast
;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

add16:        push   acc                  ;geen registers gebruiken behalve rx
              push   psw
              mov    a,r0                 ;starten met de optelling
              add    a,r2                 ;8 bit klaar
              mov    r0,a                 ;uitkomst wegschrijven
              mov    a,r1                 ;volgende 8 bit
              addc   a,r3                 ;16 bit klaar
              mov    r1,a                 ;uitkomst weggeschreven
              mov    a,#000h              ;carry verrekenen
              addc   a,#000h
              mov    r2,a                 ;24 bit klaar
              pop    psw                  ;registers herstellen
              pop    acc
              ret

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;
; sub32       zal het verschil berekenen van 2 32 bit getallen. De uitkomst is
;             40 bit groot. (eerste -tweede)
; input:      r3,r2,r1,r0 = eerste getal (r3=msb)
;             r7,r6,r5,r4 = tweede getal (r7=msb)
; output:     r4,r3,r2,r1,r0 (r4=msb)
;
; r4,r3,r2,r1,r0 worden aangepast
;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

sub32:        push   acc                  ;registers bewaren
              push   psw                  ;ook de vlaggen
              clr    c                    ;zit nog effe in de weg
              mov    a,r0                 ;eerste 8 bit
              subb   a,r4
              mov    r0,a
              mov    a,r1                 ;tweede 8 bit
              subb   a,r5
              mov    r1,a
              mov    a,r2                 ;volgende 8 bit
              subb   a,r6
              mov    r2,a
              mov    a,r3                 ;laatste 8 bit
              subb   a,r7
              mov    r3,a
              mov    a,#000h              ;nu nog de carry
              subb   a,#000h
              mov    r4,a                 ;40 bit klaar
              pop    psw                  ;registers herstellen
              pop    acc
              ret

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;
; sub16       zal het verschil berekenen van 2 16 bit getallen. De uitkomst is
;             24 bit groot. (eerste - tweede)
; input:      r1,r0 = eerste getal (r1=msb)
;             r3,r2 = tweede getal (r3=msb)
; output:     r2,r1,r0 (r2=msb)
;
; r3,r2,r1,r0 worden aangepast
;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

sub16:        push   acc                  ;registers bewaren
              push   psw
              clr    c                    ;mag nog niet meespelen
              mov    a,r0                 ;eerste 8 bit verschil
              subb   a,r2
              mov    r0,a                 ;klaar
              mov    a,r1
              subb   a,r3                 ;16 bit klaar
              mov    r1,a
              mov    a,#000h
              subb   a,#000h              ;eventuele carry verrekenen
              mov    r2,a                 ;24 bit klaar
              pop    psw                  ;registers herstellen
              pop    acc
              ret

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;
; hexbcd16    zet een 16 bit hex getal om in een 24 bit bcd getal
; input       r1,r0 = 16 bit hex getal (r1=msb)
; output      r2,r1,r0 =24 bit bcd getal (r2=msb)
;
; de routine gebruikt alleen de registers r3,r2,r1,r0 van de huidige bank 
;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

hexbcd16:     push   acc                  ;registers effe bewaren op de stack
              push   psw

              push   h7                   ;nodig
              push   h8

              push   h9                   ;ook

              mov    h9,#005h             ;loopcounter
              
hexbcd161:    mov    r3,#000h
              mov    r2,#00ah             ;hierdoor delen we
              lcall  div16                ;deling uitvoeren
              mov    a,r0                 ;rest
              push   acc                  ;op stack zetten
              mov    a,r2
              mov    r0,a
              mov    a,r3
              mov    r1,a                 ;uitkomst terug delen
              djnz   h9,hexbcd161

              pop    acc                  ;hoogste bits van de stack
              mov    r2,a                 ;klaar
              pop    acc
              swap   a
              mov    h9,a
              pop    acc
              add    a,h9
              mov    r1,a                 ;volgende 8 klaar
              pop    acc
              swap   a
              mov    h9,a
              pop    acc
              add    a,h9
              mov    r0,a                 ;klaar

              pop    h9                   ;was naar de knoppen

              pop    h8                   ;gebruikt
              pop    h7

              pop    psw                  ;registers herstellen
              pop    acc
              ret

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;
; hexbcd8     zet een 8 bit hex getal om in een 8 bit bcd getal
; input       a (maximale waarde = 63h)
; output      a
;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

hexbcd8:      push   psw                  ;registers op stack zetten
              push   b
              mov    b,#00ah              ;hierdoor delen
              div    ab                   ;in accu qoutient in b rest
              swap   a
              add    a,b                  ;bcd getal klaar
              pop    b
              pop    psw
              ret

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;
; bcdhex16    zal een 16 bit bcd getal omzetten naar een hex getal.
; input:       r1,r0 = 16 bit bcd getal (r1=msb)
; output:      r1,r0 = 16 bit hex getal (r1=msb)
;
; de routine gebruikt r1,r0 van de huidige bank
;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

bcdhex16:     push   b                    ;hebben we nodig
              push   acc
              push   psw

              mov    a,r0
              anl    a,#00fh              ;eenheden
              push   acc                  ;effe bewaren

              mov    a,r0
              swap   a
              anl    a,#00fh              ;tientallen
              mov    b,#00ah              ;waarde berekenen
              mul    ab                   ;klaar
              pop    b                    ;truukje
              add    a,b                  ;a is lage deel hex getal
              push   acc                  ;straks nodig

              mov    a,r1                 ;hoge deel 
              anl    a,#0f0h
              swap   a
              push   acc                  ;straks nodig

              mov    a,r1
              anl    a,#00fh              ;gaan we verder bewerken
              mov    b,#100d              ;waarde uitrekenen
              mul    ab
              mov    r1,b
              mov    r0,a

              pop    acc
              mov    b,#10d
              mul    ab                   ;kan nog in a
              mov    b,#100d              ;*10*100=*1000
              mul    ab
              add    a,r0
              mov    r0,a
              mov    a,r1
              addc   a,b
              mov    r1,a

              pop    acc
              add    a,r0
              mov    r0,a
              mov    a,#000h
              addc   a,r1
              mov    r1,a                 ;klaar

              pop    psw
              pop    acc
              pop    b
              ret

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;
; bcdhex8     zal een 8 bit bcd getal omzetten naar een hex getal.
; input:      a (maximale waarde 99d)
; output:     a
;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

bcdhex8:      push   psw                  ;registers op de stack zetten
              push   b
              push   h0
              mov    h0,a                 ;effe bewaren
              anl    h0,#00fh             ;alleen 4 laagste bits
              anl    a,#0f0h              ;hier alleen 4 hoogste bits
              swap   a
              mov    b,#00ah              ;berekenen waarde 4 hoogste bits
              mul    ab
              add    a,h0                 ;eenheden bijtellen
              pop    h0
              pop    b
              pop    psw
              ret